home *** CD-ROM | disk | FTP | other *** search
/ Workbench Add-On / Workbench Add-On - Volume 1.iso / BBS-Archive / Comm / AmiTCP30b2.lha / src / amitcp / kern / uipc_mbuf.c < prev    next >
C/C++ Source or Header  |  1993-08-12  |  22KB  |  907 lines
  1. RCS_ID_C = "$Id: uipc_mbuf.c,v 1.18 1993/06/04 11:16:15 jraja Exp $";
  2. /*
  3.  * Copyright (c) 1993 AmiTCP/IP Group, <amitcp-group@hut.fi>
  4.  *                    Helsinki University of Technology, Finland.
  5.  *                    All rights reserved.
  6.  *
  7.  * Last modified: Fri Jun  4 00:36:45 1993 jraja
  8.  *
  9.  * HISTORY
  10.  * $Log: uipc_mbuf.c,v $
  11.  * Revision 1.18  1993/06/04  11:16:15  jraja
  12.  * Fixes for first public release.
  13.  *
  14.  * Revision 1.17  1993/05/29  20:57:23  jraja
  15.  * Added function mb_read_stats() to return mbuf type specific statistics.
  16.  *
  17.  * Revision 1.16  1993/05/16  15:20:25  ppessi
  18.  * Fixed bug with cluster allocation.
  19.  *
  20.  * Revision 1.16  1993/05/16  15:20:25  ppessi
  21.  * Fixed bug with cluster allocation.
  22.  *
  23.  * Revision 1.15  93/05/04  12:52:25  12:52:25  jraja (Jarno Tapio Rajahalme)
  24.  * Fixed default values of the configuration variables.
  25.  * 
  26.  * Revision 1.14  93/04/25  02:59:37  02:59:37  jraja (Jarno Tapio Rajahalme)
  27.  * Added some comments.
  28.  * 
  29.  * Revision 1.13  93/04/24  22:19:41  22:19:41  jraja (Jarno Tapio Rajahalme)
  30.  * Removed MBTYPES, moved configurable variables to a structure (mbconf),
  31.  * removed nmbufs and nmbclusters (already in mbstat), moved mbufmemsize to
  32.  * mbstat (as m_memused), added configuration notify function 
  33.  * mb_check_conf() to validate configurable variables,
  34.  * added checks for maximum memory usage,
  35.  * removed m_retryhdr(), since m_retry() is already called by MGETHDR,
  36.  * removed all USECLUSTERS (now using clusters always.
  37.  * 
  38.  * Revision 1.12  93/04/23  02:26:28  02:26:28  ppessi (Pekka Pessi)
  39.  * Added some configureable parameters
  40.  * 
  41.  * Revision 1.11  93/04/13  22:31:51  22:31:51  jraja (Jarno Tapio Rajahalme)
  42.  * Added #ifdef USECLUSTERS ... #endif to compile without.
  43.  * 
  44.  * Revision 1.10  93/04/06  15:16:04  15:16:04  jraja (Jarno Tapio Rajahalme)
  45.  * Changed spl function return value storage to spl_t,
  46.  * changed bcopys and bzeros to aligned and/or const when possible,
  47.  * added inclusion of conf.h to every .c file.
  48.  * 
  49.  * Revision 1.9  93/04/02  01:08:17  01:08:17  jraja (Jarno Tapio Rajahalme)
  50.  * Implemented clusters.
  51.  * Updated memory allocation.
  52.  * Added memHeader structure to keep account of allocated memory.
  53.  * 
  54.  * Revision 1.8  93/03/05  03:26:21  03:26:21  ppessi (Pekka Pessi)
  55.  * Compiles with SASC. Initial test version.
  56.  * 
  57.  * Revision 1.7  93/03/04  09:55:46  09:55:46  jraja (Jarno Tapio Rajahalme)
  58.  * Fixed includes.
  59.  * 
  60.  * Revision 1.6  93/03/03  19:59:29  19:59:29  jraja (Jarno Tapio Rajahalme)
  61.  * Added static initializers to globals.
  62.  * 
  63.  * Revision 1.5  93/03/03  19:20:43  19:20:43  jraja (Jarno Tapio Rajahalme)
  64.  * Moved some definitions from sys/mbuf.h to here.
  65.  * 
  66.  * Revision 1.4  93/02/24  12:55:20  12:55:20  jraja (Jarno Tapio Rajahalme)
  67.  * Changed init to remember if initialized.
  68.  * 
  69.  * Revision 1.3  93/01/06  19:24:53  19:24:53  jraja (Jarno Tapio Rajahalme)
  70.  * Ported this for AmigaOS. Added function mbdeinit(), which is used to free
  71.  * memory allocated by mbuf subsystem.
  72.  * Alse commented all memory cluster related stuff with #ifdef USECLUSTERS.
  73.  * 
  74.  * Revision 1.2  92/11/20  15:14:25  15:14:25  jraja (Jarno Tapio Rajahalme)
  75.  * Added #ifndef AMITCP's to make this compile.
  76.  * 
  77.  * Revision 1.1  92/11/19  12:07:15  12:07:15  jraja (Jarno Tapio Rajahalme)
  78.  * Initial revision
  79.  */
  80.  
  81. /* 
  82.  * Mach Operating System
  83.  * Copyright (c) 1992 Carnegie Mellon University
  84.  * All Rights Reserved.
  85.  * 
  86.  * Permission to use, copy, modify and distribute this software and its
  87.  * documentation is hereby granted, provided that both the copyright
  88.  * notice and this permission notice appear in all copies of the
  89.  * software, derivative works or modified versions, and any portions
  90.  * thereof, and that both notices appear in supporting documentation.
  91.  * 
  92.  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
  93.  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
  94.  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  95.  * 
  96.  * Carnegie Mellon requests users of this software to return to
  97.  * 
  98.  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  99.  *  School of Computer Science
  100.  *  Carnegie Mellon University
  101.  *  Pittsburgh PA 15213-3890
  102.  * 
  103.  * any improvements or extensions that they make and grant Carnegie Mellon 
  104.  * the rights to redistribute these changes.
  105.  */
  106. /*
  107.  * HISTORY
  108.  * Log:    uipc_mbuf.c,v
  109.  * Revision 2.2  92/06/25  17:25:22  mrt
  110.  *     Preallocate mbufs in a chunk.
  111.  *     [92/06/24            rwd]
  112.  * 
  113.  * Revision 2.1  92/04/21  17:12:59  rwd
  114.  * BSDSS
  115.  * 
  116.  *
  117.  */
  118.  
  119. /*
  120.  * Copyright (c) 1982, 1986, 1988, 1991 Regents of the University of California.
  121.  * All rights reserved.
  122.  *
  123.  * Redistribution and use in source and binary forms, with or without
  124.  * modification, are permitted provided that the following conditions
  125.  * are met:
  126.  * 1. Redistributions of source code must retain the above copyright
  127.  *    notice, this list of conditions and the following disclaimer.
  128.  * 2. Redistributions in binary form must reproduce the above copyright
  129.  *    notice, this list of conditions and the following disclaimer in the
  130.  *    documentation and/or other materials provided with the distribution.
  131.  * 3. All advertising materials mentioning features or use of this software
  132.  *    must display the following acknowledgement:
  133.  *    This product includes software developed by the University of
  134.  *    California, Berkeley and its contributors.
  135.  * 4. Neither the name of the University nor the names of its contributors
  136.  *    may be used to endorse or promote products derived from this software
  137.  *    without specific prior written permission.
  138.  *
  139.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  140.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  141.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  142.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  143.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  144.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  145.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  146.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  147.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  148.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  149.  * SUCH DAMAGE.
  150.  *
  151.  *    @(#)uipc_mbuf.c    7.19 (Berkeley) 4/20/91
  152.  */
  153.  
  154. #include <conf.h>
  155.  
  156. #include <sys/param.h>
  157. #include <sys/malloc.h>
  158. #include <sys/mbuf.h>
  159. #include <sys/kernel.h>
  160. #include <sys/syslog.h>
  161. #include <sys/systm.h>
  162. #include <sys/domain.h>
  163. #include <sys/protosw.h>
  164. #include <sys/synch.h>
  165.  
  166. #include <kern/amiga_includes.h>
  167.  
  168. #include <dos/rdargs.h>
  169.  
  170. /*
  171.  * Configuration information.
  172.  */
  173. struct mbconf mbconf = {
  174.   2,                        /* # of mbuf chunks to allocate initially */
  175.   64,                /* # of mbufs to allocate at a time */
  176.   4,                /* # of clusters to allocate at a time */
  177.   256,                /* maximum memory to use (in kilobytes) */
  178.   2048                /* size of the mbuf cluster */
  179. };
  180.  
  181. /*
  182.  * List of free mbufs. Access to this list is protected by splimp()
  183.  */
  184. struct mbuf *mfree = NULL;
  185.  
  186. struct    mbstat mbstat = { 0 };
  187.  
  188. struct    mcluster *mclfree = NULL;
  189.  
  190. int    max_linkhdr = 0;        /* largest link-level header */
  191. int    max_protohdr = 0;        /* largest protocol header */
  192. int    max_hdr = 0;            /* largest link+protocol header */
  193. int    max_datalen = 0;        /* MHLEN - max_hdr */
  194.  
  195. /*
  196.  * Header structure that is placed at the start of every allocated memory 
  197.  * region to be freed on deinit. All memory alloctions are thus 
  198.  * sizeof(memHeader) larger and the data pointer is set past this header
  199.  * before used. These headers are linked together and the mbufmem pointer 
  200.  * holds the pointer to the start of the list.
  201.  */
  202. struct memHeader {
  203.   struct memHeader *next;
  204.   ULONG             size;
  205. };
  206.  
  207. static struct memHeader *mbufmem = NULL;
  208.  
  209. static BOOL initialized = FALSE;
  210.  
  211. LONG mb_read_stats(struct CSource *args, UBYTE **errstrp, struct CSource *res)
  212. {
  213.   int i, total = 0;
  214.   UBYTE *p = res->CS_Buffer;
  215.  
  216.   for(i = 0; i < MTCOUNT; i++) {
  217.     p += sprintf(p, "%ld ", mbstat.m_mtypes[i]);
  218.     total += mbstat.m_mtypes[i];
  219.   }
  220.   p += sprintf(p, "%ld", total);
  221.  
  222.   res->CS_CurChr = p - res->CS_Buffer;
  223.   return RETURN_OK;
  224. }
  225.  
  226. int 
  227. mb_check_conf(void *dp, LONG newvalue)
  228. {
  229.   if ((u_long *)dp == &mbconf.initial_mbuf_chunks) {
  230.     if (newvalue > 0)
  231.       return TRUE;
  232.   }
  233.   else 
  234.   if (dp == &mbconf.mbufchunk) {
  235.     if (newvalue >= 32)
  236.       return TRUE;
  237.   }
  238.   else 
  239.   if (dp == &mbconf.clusterchunk) {
  240.     if (newvalue > 0)
  241.       return TRUE;
  242.   }
  243.   else 
  244.   if (dp == &mbconf.maxmem) {
  245.     if (newvalue > 32)        /* kilobytes */
  246.       return TRUE;
  247.   }
  248.   else 
  249.   if (dp == &mbconf.mclbytes) {
  250.     if (newvalue >= MINCLSIZE)
  251.       return TRUE;
  252.   }
  253.   
  254.   return FALSE;
  255. } 
  256.  
  257. /*
  258.  * mbinit() must be called before any other mbuf related function (exept the
  259.  * mb_check_conf() which is called at configuration time). This
  260.  * allocates memory from the system in one big chunk. This memory will not be
  261.  * freed until AMITCP/IP is shut down.
  262.  */
  263.  
  264. BOOL
  265. mbinit(void)
  266. {
  267.   spl_t s;
  268.  
  269.   /*
  270.    * Return success if already initialized
  271.    */
  272.   if (initialized)
  273.     return TRUE;
  274.  
  275.   s = splimp();
  276.   /*
  277.    * Initialize the list headers to NULL
  278.    */
  279.   mfree = NULL;
  280.   mclfree = NULL;
  281.  
  282.   /*
  283.    * Preallocate some mbufs and mbuf clusters.
  284.    */
  285.   initialized = 
  286.     (m_alloc(mbconf.initial_mbuf_chunks * mbconf.mbufchunk, M_WAIT)
  287.      && m_clalloc(mbconf.clusterchunk, M_WAIT));
  288.  
  289.   splx(s);
  290.   
  291.   if (!initialized) {
  292.     log(LOG_ERR, "mbinit: Failed to allocate memory.");
  293.     mbdeinit();
  294.   }
  295.   return (initialized);
  296. }
  297.  
  298. /*
  299.  * Free all memory allocated by mbuf subsystem. This must be the last mbuf
  300.  * related function called. (Implying that NO mbuf allocations should be done
  301.  * concurrently with this!)
  302.  *
  303.  * This is new function to AMITCP/IP.
  304.  */
  305. void
  306. mbdeinit(void)
  307. {
  308.   struct memHeader *next;
  309.  
  310.   /*
  311.    * free all memory chunks
  312.    */
  313.   while (mbufmem) {
  314.     next = mbufmem->next;
  315.     mbstat.m_memused -= mbufmem->size;
  316.     FreeMem(mbufmem, mbufmem->size);
  317.     mbufmem = next;
  318.   }
  319.   initialized = FALSE;
  320. }
  321.  
  322. /*
  323.  * Allocate memory for mbufs.
  324.  * and place on the mbuf free list.
  325.  * The canwait argument is currently ignored.
  326.  *
  327.  * MUST be called at splimp!
  328.  */
  329. BOOL
  330. m_alloc(int howmany, int canwait)
  331. {
  332.  /*
  333.   * Note that mbufs must be aligned on MSIZE boundary
  334.   * for dtom to work correctly. This is archieved by allocating size for one 
  335.   * additional mbuf per chunk so that given memory can be aligned properly.
  336.   */ 
  337.   struct mbuf *m;
  338.   struct memHeader *mh;
  339.   ULONG  size;
  340.  
  341.   size = MSIZE * (howmany + 1) + sizeof(struct memHeader);
  342.  
  343.   /*
  344.    * check if allowed to allocate more
  345.    */
  346.   if (mbstat.m_memused + size > mbconf.maxmem * 1024) {
  347.     log(LOG_ERR, "m_alloc: max amount of memory already used (%ld bytes).",
  348.     mbstat.m_memused);
  349.     return FALSE;
  350.   }
  351.  
  352.   mh = AllocMem(size, MEMF_PUBLIC);    /* public since used from interrupts */
  353.   if (mh == NULL) {
  354.     log(LOG_ERR, "m_alloc: Cannot allocate memory for mbufs.");
  355.     return FALSE;
  356.   }
  357.  
  358.   /*
  359.    * initialize the memHeader and link it to the chain of allocated memory 
  360.    * blocks
  361.    */
  362.   mbstat.m_memused += size;        /* add to the total */
  363.   mh->size = size;
  364.   mh->next = mbufmem;
  365.   mbufmem = mh;
  366.   mh++;                /* pass by the memHeader */
  367.  
  368.   /*
  369.    * update the statistics
  370.    */
  371.   mbstat.m_mbufs += howmany;
  372.  
  373.   /*
  374.    * link mbufs into the free list
  375.    */
  376.   m = dtom(((caddr_t)mh) + MSIZE - 1); /* correctly aligned mbuf pointer */
  377.   while(howmany--) {
  378.     m->m_next = mfree;
  379.     mfree = m++;
  380.   }
  381.   return TRUE;
  382. }  
  383.  
  384. /*
  385.  * Allocate some number of mbuf clusters
  386.  * and place on cluster free list.
  387.  * The canwait argument is currently ignored.
  388.  * MUST be called at splimp.
  389.  */
  390. BOOL
  391. m_clalloc(int ncl, int canwait)
  392. {
  393.   struct memHeader *mh;
  394.   struct mcluster *p;
  395.   ULONG  size;
  396.   short  i;
  397.  
  398.   /*
  399.    * struct mcluster has variable length buffer so its size is not calculated
  400.    * in sizeof(struct mcluster). The size of the buffer is mbconf.mclbytes.
  401.    * Each memory block allocated is prepended by the memHeader, so size
  402.    * must be allocted for it, too.
  403.    */
  404.   size = ncl * (sizeof(struct mcluster) + mbconf.mclbytes)
  405.     + sizeof(struct memHeader);
  406.  
  407.   /*
  408.    * check if allowed to allocate more
  409.    */
  410.   if (mbstat.m_memused + size > mbconf.maxmem * 1024) {
  411.     log(LOG_ERR, "m_clalloc: max amount of memory already used (%ld bytes).",
  412.     mbstat.m_memused);
  413.     return FALSE;
  414.   }
  415.  
  416.   mh = AllocMem(size, MEMF_PUBLIC); /* public since used from interrupts */
  417.   if (mh == NULL) {
  418.     log(LOG_ERR, "m_clalloc: Cannot allocate memory for mbuf clusters");
  419.     return FALSE;
  420.   }
  421.   /*
  422.    * initialize the memHeader and link it to the chain of allocated memory 
  423.    * blocks
  424.    */
  425.   mbstat.m_memused += size;
  426.   mh->size = size;
  427.   mh->next = mbufmem;
  428.   mbufmem = mh;
  429.   mh++;                /* pass by the memHeader */
  430.   /*
  431.    * link clusters to the free list
  432.    */
  433.   for (i = 0, p = (struct mcluster *)mh; 
  434.        i < ncl; 
  435.        i++, p = (struct mcluster*)((char *)(p + 1) + mbconf.mclbytes)) {
  436.     p->mcl.mcl_next = mclfree;
  437.     mclfree = p;
  438.     mbstat.m_clfree++;
  439.   }
  440.   mbstat.m_clusters += ncl;
  441.   
  442.   return TRUE;
  443. }
  444.  
  445. /*
  446.  * When MGET failes, ask protocols to free space when short of memory,
  447.  * then re-attempt to allocate an mbuf.
  448.  *
  449.  * Allocate more memory for mbufs if there still are no mbufs left 
  450.  *
  451.  * MUST be called at splimp.
  452.  */
  453. struct mbuf *
  454. m_retry(int canwait, int type)
  455. {
  456.   register struct mbuf *m;
  457.  
  458.   m_reclaim();
  459.  
  460.   /*
  461.    * Try to allocate more memory if still no free mbufs
  462.    */
  463.   if (!mfree)
  464.     m_alloc(mbconf.mbufchunk, canwait);
  465.   
  466. #define m_retry(i, t)    /*mbstat.m_drops++,*/NULL
  467.   MGET(m, canwait, type);
  468. #undef m_retry
  469.   return (m);
  470. }
  471.  
  472. void
  473. m_reclaim()
  474. {
  475.     register struct domain *dp;
  476.     register struct protosw *pr;
  477.     spl_t s = splimp();
  478.  
  479.     for (dp = domains; dp; dp = dp->dom_next)
  480.         for (pr = dp->dom_protosw; pr < dp->dom_protoswNPROTOSW; pr++)
  481.             if (pr->pr_drain)
  482.                 (*pr->pr_drain)();
  483.     splx(s);
  484.     mbstat.m_drain++;
  485. }
  486.  
  487. /*
  488.  * Space allocation routines.
  489.  * These are also available as macros
  490.  * for critical paths.
  491.  */
  492. struct mbuf *
  493. m_get(canwait, type)
  494.     int canwait, type;
  495. {
  496.     register struct mbuf *m;
  497.  
  498.     MGET(m, canwait, type);
  499.     return (m);
  500. }
  501.  
  502. struct mbuf *
  503. m_gethdr(canwait, type)
  504.     int canwait, type;
  505. {
  506.     register struct mbuf *m;
  507.  
  508.     MGETHDR(m, canwait, type);
  509.     return (m);
  510. }
  511.  
  512. struct mbuf *
  513. m_getclr(canwait, type)
  514.     int canwait, type;
  515. {
  516.     register struct mbuf *m;
  517.  
  518.     MGET(m, canwait, type);
  519.     if (m == 0)
  520.         return (0);
  521.     aligned_bzero_const(mtod(m, caddr_t), MLEN);
  522.     return (m);
  523. }
  524.  
  525. struct mbuf *
  526. m_free(m)
  527.     struct mbuf *m;
  528. {
  529.     register struct mbuf *n;
  530.  
  531.     MFREE(m, n);
  532.     return (n);
  533. }
  534.  
  535. void
  536. m_freem(m)
  537.     register struct mbuf *m;
  538. {
  539.     register struct mbuf *n;
  540.  
  541.     if (m == NULL)
  542.         return;
  543.     do {
  544.         MFREE(m, n);
  545.     } while (m = n);
  546. }
  547.  
  548. /*
  549.  * Mbuffer utility routines.
  550.  */
  551.  
  552. /*
  553.  * Lesser-used path for M_PREPEND:
  554.  * allocate new mbuf to prepend to chain,
  555.  * copy junk along.
  556.  */
  557. struct mbuf *
  558. m_prepend(m, len, canwait)
  559.     register struct mbuf *m;
  560.     int len, canwait;
  561. {
  562.     struct mbuf *mn;
  563.  
  564.     MGET(mn, canwait, m->m_type);
  565.     if (mn == NULL) {
  566.         m_freem(m);
  567.         return (NULL);
  568.     }
  569.     if (m->m_flags & M_PKTHDR) {
  570.         M_COPY_PKTHDR(mn, m);
  571.         m->m_flags &= ~M_PKTHDR;
  572.     }
  573.     mn->m_next = m;
  574.     m = mn;
  575.     if (len < MHLEN)
  576.         MH_ALIGN(m, len);
  577.     m->m_len = len;
  578.     return (m);
  579. }
  580.  
  581. /*
  582.  * Make a copy of an mbuf chain starting "off0" bytes from the beginning,
  583.  * continuing for "len" bytes.  If len is M_COPYALL, copy to end of mbuf.
  584.  * The wait parameter is a choice of M_WAIT/M_DONTWAIT from caller.
  585.  */
  586. int MCFail;
  587.  
  588. struct mbuf *
  589. m_copym(m, off0, len, wait)
  590.     register struct mbuf *m;
  591.     int off0, wait;
  592.     register int len;
  593. {
  594.     register struct mbuf *n, **np;
  595.     register int off = off0;
  596.     struct mbuf *top = NULL;
  597.     int copyhdr = 0;
  598.  
  599.     if (off < 0 || len < 0) {
  600.       log(LOG_ERR, "m_copym: Bad arguments");
  601.       goto nospace;
  602.     }
  603.     if (off == 0 && m->m_flags & M_PKTHDR)
  604.         copyhdr = 1;
  605.     /*
  606.      * find first mbuf to copy data from
  607.      */
  608.     while (off > 0) {
  609.         if (m == 0) {
  610.           log(LOG_ERR, "m_copym: short mbuf chain");
  611.           goto nospace;
  612.         }
  613.         if (off < m->m_len)
  614.             break;
  615.         off -= m->m_len;
  616.         m = m->m_next;
  617.     }
  618.     np = ⊤
  619.     while (len > 0) {
  620.         if (m == 0) {
  621.             if (len != M_COPYALL) {
  622.               log(LOG_ERR, "m_copym: short mbuf chain");
  623.               goto nospace;
  624.             }
  625.             break;
  626.         }
  627.         MGET(n, wait, m->m_type);
  628.         *np = n;
  629.         if (n == 0)
  630.             goto nospace;
  631.         if (copyhdr) {
  632.             M_COPY_PKTHDR(n, m);
  633.             if (len == M_COPYALL)
  634.                 n->m_pkthdr.len -= off0;
  635.             else
  636.                 n->m_pkthdr.len = len;
  637.             copyhdr = 0;
  638.         }
  639.         n->m_len = MIN(len, m->m_len - off);
  640.  
  641.         if (m->m_flags & M_EXT) {
  642.             n->m_data = m->m_data + off;
  643.             m->m_ext.ext_buf->mcl.mcl_refcnt++;
  644.             n->m_ext = m->m_ext;
  645.             n->m_flags |= M_EXT;
  646.         } else
  647.             bcopy(mtod(m, caddr_t)+off, mtod(n, caddr_t),
  648.                 (unsigned)n->m_len);
  649.         if (len != M_COPYALL)
  650.             len -= n->m_len;
  651.         off = 0;
  652.         m = m->m_next;
  653.         np = &n->m_next;
  654.     }
  655.     if (top == 0)
  656.         MCFail++;
  657.     return (top);
  658. nospace:
  659.     m_freem(top);
  660.     MCFail++;
  661.     return NULL;
  662. }
  663.  
  664. /*
  665.  * Copy data from an mbuf chain starting "off" bytes from the beginning,
  666.  * continuing for "len" bytes, into the indicated buffer.
  667.  */
  668. void
  669. m_copydata(m, off, len, cp)
  670.     register struct mbuf *m;
  671.     register int off;
  672.     register int len;
  673.     caddr_t cp;
  674. {
  675.     register unsigned count;
  676.  
  677.     if (off < 0 || len < 0) {
  678.       log(LOG_ERR, "m_copydata: bad arguments");
  679.       return;
  680.     }
  681.     while (off > 0) {
  682.         if (m == 0) {
  683.           log(LOG_ERR, "m_copydata: short mbuf chain to copy from");
  684.           return;
  685.         }
  686.         if (off < m->m_len)
  687.             break;
  688.         off -= m->m_len;
  689.         m = m->m_next;
  690.     }
  691.     while (len > 0) {
  692.         if (m == 0) {
  693.           log(LOG_ERR, "m_copydata: short mbuf chain to copy from");
  694.           return;
  695.         }
  696.         count = MIN(m->m_len - off, len);
  697.         bcopy(mtod(m, caddr_t) + off, cp, count);
  698.         len -= count;
  699.         cp += count;
  700.         off = 0;
  701.         m = m->m_next;
  702.     }
  703. }
  704.  
  705. /*
  706.  * Concatenate mbuf chain n to m.
  707.  * Both chains must be of the same type (e.g. MT_DATA).
  708.  * Any m_pkthdr is not updated.
  709.  */
  710. void
  711. m_cat(m, n)
  712.     register struct mbuf *m, *n;
  713. {
  714.     while (m->m_next)
  715.         m = m->m_next;
  716.     while (n) {
  717.         if (m->m_flags & M_EXT ||
  718.             m->m_data + m->m_len + n->m_len >= &m->m_dat[MLEN]) {
  719.             /* just join the two chains */
  720.             m->m_next = n;
  721.             return;
  722.         }
  723.         /* splat the data from one into the other */
  724.         bcopy(mtod(n, caddr_t), mtod(m, caddr_t) + m->m_len,
  725.             (u_int)n->m_len);
  726.         m->m_len += n->m_len;
  727.         n = m_free(n);
  728.     }
  729. }
  730.  
  731. void
  732. m_adj(struct mbuf *mp, int req_len)
  733. {
  734.     register int len = req_len;
  735.     register struct mbuf *m;
  736.     register count;
  737.  
  738.     if ((m = mp) == NULL)
  739.         return;
  740.     if (len >= 0) {
  741.         /*
  742.          * Trim from head.
  743.          */
  744.         while (m != NULL && len > 0) {
  745.             if (m->m_len <= len) {
  746.                 len -= m->m_len;
  747.                 m->m_len = 0;
  748.                 m = m->m_next;
  749.             } else {
  750.                 m->m_len -= len;
  751.                 m->m_data += len;
  752.                 len = 0;
  753.             }
  754.         }
  755.         m = mp;
  756.         if (mp->m_flags & M_PKTHDR)
  757.             m->m_pkthdr.len -= (req_len - len);
  758.     } else {
  759.         /*
  760.          * Trim from tail.  Scan the mbuf chain,
  761.          * calculating its length and finding the last mbuf.
  762.          * If the adjustment only affects this mbuf, then just
  763.          * adjust and return.  Otherwise, rescan and truncate
  764.          * after the remaining size.
  765.          */
  766.         len = -len;
  767.         count = 0;
  768.         for (;;) {
  769.             count += m->m_len;
  770.             if (m->m_next == (struct mbuf *)0)
  771.                 break;
  772.             m = m->m_next;
  773.         }
  774.         if (m->m_len >= len) {
  775.             m->m_len -= len;
  776.             if ((mp = m)->m_flags & M_PKTHDR)
  777.                 m->m_pkthdr.len -= len;
  778.             return;
  779.         }
  780.         count -= len;
  781.         if (count < 0)
  782.             count = 0;
  783.         /*
  784.          * Correct length for chain is "count".
  785.          * Find the mbuf with last data, adjust its length,
  786.          * and toss data from remaining mbufs on chain.
  787.          */
  788.         m = mp;
  789.         if (m->m_flags & M_PKTHDR)
  790.             m->m_pkthdr.len = count;
  791.         for (; m; m = m->m_next) {
  792.             if (m->m_len >= count) {
  793.                 m->m_len = count;
  794.                 break;
  795.             }
  796.             count -= m->m_len;
  797.         }
  798.         while (m = m->m_next)
  799.             m->m_len = 0;
  800.     }
  801. }
  802.  
  803. /*
  804.  * Rearrange an mbuf chain so that len bytes from the beginning are
  805.  * contiguous and in the data area of an mbuf (so that mtod and dtom
  806.  * will work for a structure of size len). Note that resulting
  807.  * structure is assumed to get properly aligned. This will happen only if
  808.  * there is no odd-length data before the structure. Fortunately all
  809.  * headers are before any data in the packet and are of even length.
  810.  * Returns the resulting mbuf chain on success, frees it and returns
  811.  * null on failure. If there is room, it will add up to max_protohdr-len
  812.  * extra bytes to the contiguous region in an attempt to avoid being
  813.  * called next time.
  814.  */
  815. int MPFail;
  816.  
  817. struct mbuf *
  818. m_pullup(n, len)
  819.     register struct mbuf *n;
  820.     int len;
  821. {
  822.     register struct mbuf *m;
  823.     register int count;
  824.     int space;
  825.  
  826.     /*
  827.      * If first mbuf has no cluster, and has room for len bytes
  828.      * without shifting current data, pullup into it,
  829.      * otherwise allocate a new mbuf to prepend to the chain.
  830.      */
  831.     if ((n->m_flags & M_EXT) == 0 &&
  832.         n->m_data + len < &n->m_dat[MLEN] && n->m_next) {
  833.         if (n->m_len >= len)
  834.             return (n);
  835.         m = n;            /* pullup to */
  836.         n = n->m_next;        /* pullup from */
  837.         len -= m->m_len;     /* pullup length */
  838.     } else {
  839.         if (len > MHLEN)
  840.             goto bad;
  841.         MGET(m, M_DONTWAIT, n->m_type);
  842.         if (m == 0)
  843.             goto bad;
  844.         m->m_len = 0;
  845.         if (n->m_flags & M_PKTHDR) {
  846.             M_COPY_PKTHDR(m, n);
  847.             n->m_flags &= ~M_PKTHDR;
  848.         }
  849.     }
  850.     space = &m->m_dat[MLEN] - (m->m_data + m->m_len);
  851.     do {
  852.         count = min(min(max(len, max_protohdr), space), n->m_len);
  853.         bcopy(mtod(n, caddr_t), mtod(m, caddr_t) + m->m_len,
  854.           (unsigned)count);
  855.         len -= count;
  856.         m->m_len += count;
  857.         n->m_len -= count;
  858.         space -= count;
  859.         if (n->m_len)
  860.             n->m_data += count;
  861.         else
  862.             n = m_free(n);
  863.     } while (len > 0 && n);
  864.     if (len > 0) {
  865.         (void) m_free(m);
  866.         goto bad;
  867.     }
  868.     m->m_next = n;
  869.     return (m);
  870. bad:
  871.     m_freem(n);
  872.     MPFail++;
  873.     return (0);
  874. }
  875.  
  876. #if 0                /* not needed (yet), DO NOT DELETE! */
  877. /*
  878.  * Allocate a "funny" mbuf, that is, one whose data is owned by someone else.
  879.  */
  880. struct mbuf *
  881. mclgetx(fun, arg, addr, len, wait)
  882.         void (*fun)();
  883.         int arg, len, wait;
  884.         caddr_t addr;
  885. {
  886.         register struct mbuf *m;
  887.  
  888.         MGETHDR(m, wait, MT_DATA);
  889.         if (m == 0)
  890.                 return (0);
  891.         m->m_data = addr ;
  892.         m->m_len = len;
  893.         m->m_ext.ext_free = fun;
  894.         m->m_ext.ext_size = len;
  895.         m->m_ext.ext_buf = (caddr_t)arg;
  896.         m->m_flags |= M_EXT;
  897.  
  898.         return (m);
  899. }
  900.  
  901. void mcl_free_routine(buf, size)
  902.     char *buf;
  903.     int size;
  904. {
  905. }
  906. #endif /* 0 */
  907.